package com.ruoyi.tsjData.service.impl;

import java.util.*;
import java.util.concurrent.Future;
import java.util.stream.Collectors;

import com.alibaba.fastjson2.JSON;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.calculate.BezierCurveUtil;
import com.ruoyi.tsjData.domain.plat.DataTshjSd;
import com.ruoyi.tsjData.mapper.DataTshjSdMapper;
import com.ruoyi.tsjData.service.IDataTshjSdService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;


/**
 * 提升机-速度测试Service业务层处理
 *
 * @author ruoyi
 * @date 2023-10-25
 */
@Service
public class DataTshjSdServiceImpl implements IDataTshjSdService {

    @Autowired(required = false)
    private DataTshjSdMapper dataTshjSdMapper;

    /**
     * 查询提升机-速度测试
     *
     * @param sdId 提升机-速度测试主键
     * @return 提升机-速度测试
     */
    @Override
    public DataTshjSd selectDataTshjSdBySdId(Long sdId) {
        return dataTshjSdMapper.selectDataTshjSdBySdId(sdId);
    }

    /**
     * 速度测试数据
     *
     * @param dataTaskId
     * @return
     */
    @Override
    @Async("threadPoolKy")
    public Future<List<DataTshjSd>> selectSd(Long dataTaskId) {
        List<DataTshjSd> dataTshjSdEntities = dataTshjSdMapper.selectDataTshjSdByDataTaskId(dataTaskId);
        if (!dataTshjSdEntities.isEmpty()) {
            dataTshjSdEntities.forEach(item -> {
                if (item.getSuduNiheList() != null) {
                    // 电流曲线数据
                    item.setDlChartLineDTO(BezierCurveUtil.calPoints(item.getDlList(), 0.2f, true));
                    // 速度曲线数据
                    item.setSdChartLineDTO(BezierCurveUtil.calPoints(item.getSuduNiheList(), 0.1f, true));
                    // 速度拟合曲线数据
                    item.setSdNiheChartLineDTO(BezierCurveUtil.calPoints(item.getSuduNiheList(), 0.1f, false));
                    List<Float> suduVelList = JSON.parseArray(item.getSuduNiheList(), Float.class);
                    List<Float> q40List = suduVelList.subList(0, suduVelList.size() < 400 ? suduVelList.size() - 1 : 400);
                    List<Float> h40List = suduVelList.subList(suduVelList.size() > 400 ? suduVelList.size() - 400 : 0, suduVelList.size() - 1);
                    // 前40s速度曲线数据
                    item.setSdQ40ChartLineDTO(BezierCurveUtil.calPoints(q40List, 0.1f, false));
                    // 后40s速度曲线数据
                    item.setSdH40ChartLineDTO(BezierCurveUtil.calPoints(h40List, 0.1f, false));
                    // 加速度集合
                    List<Float> jsdVelList = new ArrayList<>();
                    jsdVelList.add(0f);
                    for (int i = 1; i < suduVelList.size(); i++) {
                        jsdVelList.add(Math.abs(suduVelList.get(i) - suduVelList.get(i - 1) / 0.1f) <= 0.7 ? (suduVelList.get(i) - suduVelList.get(i - 1)) / 0.1f * 0.5f : (suduVelList.get(i) - suduVelList.get(i - 1)) / 0.1f);
                    }
                    // 加速度曲线数据
                    item.setJsdChartLineDTO(BezierCurveUtil.calPoints(jsdVelList, 0.1f, false));
                    // 井深速度图
                    List<Float> jsList = new ArrayList<>();
                    float sum = 0f;
                    for (Float sdVel : suduVelList) {
                        sum += (sdVel * 0.1f);
                        jsList.add(sum);
                    }
                    float sum_last = jsList.get(jsList.size() - 1);
                    //系数
                    float sumRatio = sum_last == 0 ? 0f : Float.parseFloat(item.getParaTshjl()) / sum_last;
                    List<Float> jsDdList = new ArrayList<>();
                    List<Float> suduList = new ArrayList<>();
                    for (int k = 0; k < jsList.size(); k++) {
                        float key = jsList.get(k) * sumRatio;
                        if(!jsDdList.contains(key)) {
                            jsDdList.add(key);
                            suduList.add(suduVelList.get(k));
                        }
                    }
                    item.setSdjshChartLineDTO(BezierCurveUtil.calPoints(jsDdList, suduList, true));
                }
            });
        }
        return new AsyncResult<>(dataTshjSdEntities);
    }


    /**
     * 查询提升机-速度测试
     *
     * @param dataTaskId 提升机-速度测试任务id
     * @return 提升机-速度测试
     */
    @Override
    public List<DataTshjSd> selectDataTshjSdByDataTaskId(Long dataTaskId) {
        return dataTshjSdMapper.selectDataTshjSdByDataTaskId(dataTaskId);
    }

    /**
     * 查询提升机-速度测试列表
     *
     * @param dataTshjSd 提升机-速度测试
     * @return 提升机-速度测试
     */
    @Override
    public List<DataTshjSd> selectDataTshjSdList(DataTshjSd dataTshjSd) {
        return dataTshjSdMapper.selectDataTshjSdList(dataTshjSd);
    }

    /**
     * 新增提升机-速度测试
     *
     * @param dataTshjSd 提升机-速度测试
     * @return 结果
     */
    @Override
    public int insertDataTshjSd(DataTshjSd dataTshjSd) {
        dataTshjSd.setCreateTime(DateUtils.getNowDate());
        return dataTshjSdMapper.insertDataTshjSd(dataTshjSd);
    }

    /**
     * 批量新增速度数据
     *
     * @param dataTshjSds 提升机-速度测试
     * @return
     */
    @Override
    public int batchDataTshjSd(List<DataTshjSd> dataTshjSds) {
        return dataTshjSdMapper.batchDataTshjSd(dataTshjSds);
    }

    /**
     * 修改提升机-速度测试
     *
     * @param dataTshjSd 提升机-速度测试
     * @return 结果
     */
    @Override
    public int updateDataTshjSd(DataTshjSd dataTshjSd) {
        dataTshjSd.setUpdateTime(DateUtils.getNowDate());
        return dataTshjSdMapper.updateDataTshjSd(dataTshjSd);
    }

    /**
     * 批量修改提升机-速度测试
     *
     * @param dataTshjSds 提升机-速度测试
     * @return
     */
    @Override
    public int updateBatchDataTshjSd(List<DataTshjSd> dataTshjSds) {
        return dataTshjSdMapper.batchDataTshjSd(dataTshjSds);
    }

    /**
     * 修改速度测试任务
     *
     * @param dataTaskIds 速度测试任务id
     * @return
     */
    @Override
    public int updateDataTshjSdByDataTaskIds(Long[] dataTaskIds) {
        return dataTshjSdMapper.updateDataTshjSdByDataTaskIds(dataTaskIds);
    }

    /**
     * 变更速度测试任务状态为2
     * @param dataTaskId
     * @param sdId
     * @return
     */
    @Override
    public int updateDataTshjSdBySdId(Long dataTaskId, Long sdId) {
        return dataTshjSdMapper.updateDataTshjSdBySdId(dataTaskId, sdId);
    }

    /**
     * 批量删除提升机-速度测试
     *
     * @param sdIds 需要删除的提升机-速度测试主键
     * @return 结果
     */
    @Override
    public int deleteDataTshjSdBySdIds(Long[] sdIds) {
        return dataTshjSdMapper.deleteDataTshjSdBySdIds(sdIds);
    }

    /**
     * 删除提升机-速度测试信息
     *
     * @param sdId 提升机-速度测试主键
     * @return 结果
     */
    @Override
    public int deleteDataTshjSdBySdId(Long sdId) {
        return dataTshjSdMapper.deleteDataTshjSdBySdId(sdId);
    }
}
